/**************************************************************************/
// FIXME: Why is this code doing its own byte order conversion?
-static unsigned int byte_order(void)
+static unsigned int byte_order()
{
unsigned long test = BYTEORDER_TEST;
unsigned char* ptr;
return WP;
}
-static void wpr_read(void)
+static void wpr_read()
{
struct wprdata wprdata;
struct rtehdr* rtehdr;
}
}
-static void trl_read(void)
+static void trl_read()
{
struct trldata trldata;
struct trkhdr* trkhdr;
/* should we do some final sanity checks? */
}
-static void wpr_write(void)
+static void wpr_write()
{
int i;
TRL.loghdr.num = -1;
}
-static void trl_write(void)
+static void trl_write()
{
struct trkhdr* trkhdr;
void* buf;
fin = gbfopen(fname, "rb", MYNAME);
}
-static void alan_rd_deinit(void)
+static void alan_rd_deinit()
{
gbfclose(fin);
fin = NULL;
fout = gbfopen(fname, "wb", MYNAME);
}
-static void alan_wr_deinit(void)
+static void alan_wr_deinit()
{
gbfclose(fout);
fout = NULL;
}
-static void alan_exit(void)
+static void alan_exit()
{
return;
}
}
static void
-Init_Wpt_Type(void)
+Init_Wpt_Type()
{
if (!opt_wpt_type || !opt_wpt_type[0]) {
wpt_type_num = 1; /* marker */
}
static void
-Init_Output_Type(void)
+Init_Output_Type()
{
if (!output_type || !output_type[0]) {
output_type_num = last_read_type;
}
static void
-Free_Road_Changes(void)
+Free_Road_Changes()
{
int i = 0;
if (roadchanges) {
}
static void
-Init_Road_Changes(void)
+Init_Road_Changes()
{
int count = 0;
char* strType = NULL;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(infile);
}
static void
-my_read(void)
+my_read()
{
Read_AN1_Header(infile);
Read_AN1_Bitmaps(infile);
}
static void
-wr_deinit(void)
+wr_deinit()
{
Free_Road_Changes();
gbfclose(outfile);
}
static void
-my_write(void)
+my_write()
{
Write_AN1_Header(outfile);
Write_AN1_Bitmaps(outfile);
}
static void
-bcr_init_radius(void)
+bcr_init_radius()
{
if (radius_opt != NULL) { /* preinitialize the earth radius */
radius = atof(radius_opt);
}
static void
-bcr_rd_deinit(void)
+bcr_rd_deinit()
{
inifile_done(ini);
}
/* ------------------------------------------------------------- */
static void
-bcr_data_read(void)
+bcr_data_read()
{
int index;
char* str;
}
static void
-bcr_wr_deinit(void)
+bcr_wr_deinit()
{
gbfclose(fout);
}
}
static void
-bcr_data_write(void)
+bcr_data_write()
{
target_rte_num = 1;
}
}
-static void rd_deinit(void)
+static void rd_deinit()
{
gbser_deinit(serial_handle);
serial_handle = NULL;
return remaining;
}
-static void data_read(void)
+static void data_read()
{
unsigned char ibuf[25];
int rd_cnt;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
mkshort_del_handle(&mkshort_handle);
ofname.clear();
* Each file contains a single waypoint.
*/
static void
-bushnell_read(void)
+bushnell_read()
{
int32_t lat_tmp,lon_tmp;
unsigned int proximity;
}
static void
-bushnell_write(void)
+bushnell_write()
{
waypt_disp_all(bushnell_write_one);
}
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
int i = trkpt_count;
while (i < 4502) {
* Each file contains a single waypoint.
*/
static void
-bushnell_read(void)
+bushnell_read()
{
int lat_tmp,lon_tmp;
}
static void
-bushnell_write(void)
+bushnell_write()
{
track_disp_all(NULL, NULL, bushnell_write_one);
}
};
void
-cet_register(void)
+cet_register()
{
int i, c;
}
void
-cet_deregister(void)
+cet_deregister()
{
int i;
int j = cet_cs_alias_ct;
}
void
-cet_convert_deinit(void)
+cet_convert_deinit()
{
global_opts.charset = NULL;
global_opts.codec = NULL;
}
static void
-cet_flag_all(void)
+cet_flag_all()
{
waypt_disp_all(cet_flag_waypt);
route_disp_all(cet_flag_route, NULL, cet_flag_waypt);
}
static void
-cst_rd_deinit(void)
+cst_rd_deinit()
{
gbfclose(fin);
}
/* --------------------------------------------------------------------------- */
static void
-cst_data_read(void)
+cst_data_read()
{
char* buff;
int line = 0;
}
static void
-gpl_read(void)
+gpl_read()
{
Waypoint* wpt_tmp;
route_head* track_head;
static void
-gpl_rd_deinit(void)
+gpl_rd_deinit()
{
gbfclose(gplfile_in);
}
}
static void
-gpl_wr_deinit(void)
+gpl_wr_deinit()
{
gbfclose(gplfile_out);
}
}
static void
-gpl_write(void)
+gpl_write()
{
track_disp_all(NULL, NULL, gpl_trackpt);
}
}
static void
-destinator_read_poi(void)
+destinator_read_poi()
{
Waypoint* wpt;
int count = 0;
}
static void
-destinator_read_rte(void)
+destinator_read_rte()
{
int count = 0;
route_head* rte = NULL;
}
static void
-destinator_read_trk(void)
+destinator_read_trk()
{
char TXT[4] = "TXT";
int recno = -1;
}
static void
-destinator_read(void)
+destinator_read()
{
int i0, i1;
double d0, d1;
}
static void
-destinator_rd_deinit(void)
+destinator_rd_deinit()
{
gbfclose(fin);
}
static void
-destinator_read_poi_wrapper(void)
+destinator_read_poi_wrapper()
{
data_type = wptdata;
destinator_read();
}
static void
-destinator_read_rte_wrapper(void)
+destinator_read_rte_wrapper()
{
data_type = rtedata;
destinator_read();
}
static void
-destinator_read_trk_wrapper(void)
+destinator_read_trk_wrapper()
{
data_type = trkdata;
destinator_read();
}
static void
-destinator_wr_deinit(void)
+destinator_wr_deinit()
{
gbfclose(fout);
}
static void
-destinator_write_poi(void)
+destinator_write_poi()
{
waypt_disp_all(destinator_wpt_disp);
}
static void
-destinator_write_rte(void)
+destinator_write_rte()
{
route_disp_all(NULL, NULL, destinator_rtept_disp);
}
static void
-destinator_write_trk(void)
+destinator_write_trk()
{
track_disp_all(NULL, NULL, destinator_trkpt_disp);
}
}
static void
-dg100_rd_deinit(void)
+dg100_rd_deinit()
{
gbser_deinit(serial_handle);
serial_handle = NULL;
}
static void
-dg100_read(void)
+dg100_read()
{
if (*erase_only == '1') {
dg100_erase();
static void
-read_CXMLSafe(void)
+read_CXMLSafe()
{
char* xmlstr = NULL;
#endif
static void
-read_XML(void)
+read_XML()
{
xml_init(fin->name, tlog3b_xgcb_map, NULL);
xml_read();
}
static void
-dmtlog_rd_deinit(void)
+dmtlog_rd_deinit()
{
gbfclose(fin);
}
static void
-dmtlog_read(void)
+dmtlog_read()
{
switch (gbfgetuint32(fin)) {
}
static void
-dmtlog_wr_deinit(void)
+dmtlog_wr_deinit()
{
gbfclose(fout);
}
}
static void
-dmtlog_write(void)
+dmtlog_write()
{
track_index = atoi(opt_index);
/* ... validate index */
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
}
static void
-data_read(void)
+data_read()
{
char p;
char ibuf[10];
}
static void
-data_write(void)
+data_write()
{
setshort_length(mkshort_handle, 6);
static void
-read_lap(void)
+read_lap()
{
tw_lap lap;
gbfread(&lap,sizeof(tw_lap),1,file_in);
}
static void
-rd_deinit(void)
+rd_deinit()
{
if (global_opts.debug_level > 1) {
printf (MYNAME " rd_deinit()\n");
}
static void
-track_read(void)
+track_read()
{
if(global_opts.debug_level > 1) {
printf (MYNAME " waypoint_read()\n");
}
static void
-data_read(void)
+data_read()
{
if (global_opts.debug_level > 1) {
printf (MYNAME " data_read()\n");
}
static void
-data_read(void)
+data_read()
{
struct enigma_wpt ewpt;
route_head* route = route_head_alloc();
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-data_write(void)
+data_write()
{
route_disp_all(NULL, NULL, enigma_waypt_disp);
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
}
static void
-exif_release_apps(void)
+exif_release_apps()
{
queue* e0, *t0;
}
static exif_app_t*
-exif_load_apps(void)
+exif_load_apps()
{
exif_app_t* exif_app = NULL;
}
static void
-exif_write_apps(void)
+exif_write_apps()
{
queue* e0, *t0;
}
static void
-exif_rd_deinit(void)
+exif_rd_deinit()
{
exif_release_apps();
gbfclose(fin);
}
static void
-exif_read(void)
+exif_read()
{
uint16_t soi;
Waypoint* wpt;
}
static void
-exif_wr_deinit(void)
+exif_wr_deinit()
{
exif_release_apps();
}
static void
-exif_write(void)
+exif_write()
{
time_t frame;
}
static void
-f90g_track_rd_deinit(void)
+f90g_track_rd_deinit()
{
gbfclose(fin);
}
static const float SPEED_CONVERSION = (10.0f)/(36.0f); // convert KPH to meters per second
static void
-f90g_track_read(void)
+f90g_track_read()
{
Waypoint* readWaypoint;
char northSouth, eastWest, velocityMark, ttRec[TTRECORDSIZE], tempBuf[20];
}
void
-init_filter_vecs(void)
+init_filter_vecs()
{
fl_vecs_t* vec = filter_vec_list;
while (vec->vec) {
}
void
-exit_filter_vecs(void)
+exit_filter_vecs()
{
fl_vecs_t* vec = filter_vec_list;
while (vec->vec) {
* parse for help on available command line options.
*/
void
-disp_filter_vecs(void)
+disp_filter_vecs()
{
fl_vecs_t* vec;
arglist_t* ap;
}
static void
-rw_deinit(void)
+rw_deinit()
{
if (gps_baud_rate != DEFAULT_BAUD) {
if (0 == GPS_Set_Baud_Rate(portname, DEFAULT_BAUD)) {
}
static void
-waypt_read(void)
+waypt_read()
{
int i,n;
GPS_PWay* way = NULL;
static
void
-track_read(void)
+track_read()
{
int32 ntracks;
GPS_PTrack* array;
static
void
-route_read(void)
+route_read()
{
int32 nroutepts;
int i;
}
static void
-data_read(void)
+data_read()
{
if (gpx_vec) {
gpx_vec->read();
}
static GPS_PWay
-sane_GPS_Way_New(void)
+sane_GPS_Way_New()
{
GPS_PWay way;
way = GPS_Way_New();
}
static int
-waypoint_prepare(void)
+waypoint_prepare()
{
int i;
int n = waypt_count();
}
static void
-waypoint_write(void)
+waypoint_write()
{
int i, n;
int32 ret;
}
static void
-route_write(void)
+route_write()
{
int i;
int n = 2 * route_waypt_count(); /* Doubled for the islink crap. */
}
static int
-track_prepare(void)
+track_prepare()
{
int i;
int32 n = track_waypt_count() + track_count();
}
static void
-track_write(void)
+track_write()
{
int i, n;
}
static void
-course_write(void)
+course_write()
{
int i, n_trk, n_wpt;
}
static void
-data_write(void)
+data_write()
{
if (poweroff) {
return;
}
static void
-fit_rd_deinit(void)
+fit_rd_deinit()
{
int local_id;
* fit_parse_header- parse the global FIT header
*******************************************************************************/
static void
-fit_parse_header(void)
+fit_parse_header()
{
int len;
int ver;
}
static uint8_t
-fit_getuint8(void)
+fit_getuint8()
{
int val;
}
static uint16_t
-fit_getuint16(void)
+fit_getuint16()
{
char buf[2];
}
static uint32_t
-fit_getuint32(void)
+fit_getuint32()
{
char buf[4];
* fit_parse_record- parse each record in the file
*******************************************************************************/
static void
-fit_parse_record(void)
+fit_parse_record()
{
uint8_t header;
* - parse all the records in the file
*******************************************************************************/
static void
-fit_read(void)
+fit_read()
{
fit_parse_header();
}
static void
-read_header(void)
+read_header()
{
int len, i;
#ifdef GPI_DBG
static void
-write_header(void)
+write_header()
{
time_t time = gpi_timestamp;
static void
-garmin_gpi_rd_deinit(void)
+garmin_gpi_rd_deinit()
{
delete rdata;
gbfclose(fin);
static void
-garmin_gpi_wr_deinit(void)
+garmin_gpi_wr_deinit()
{
wdata_free(wdata);
mkshort_del_handle(&short_h);
static void
-garmin_gpi_read(void)
+garmin_gpi_read()
{
while (1) {
int tag = gbfgetint32(fin);
static void
-garmin_gpi_write(void)
+garmin_gpi_write()
{
unsigned char* image;
int image_sz;
}
static void
-format_garmin_xt_rd_deinit(void)
+format_garmin_xt_rd_deinit()
{
gbfclose(fin);
}
* Main Function to process Saved tracks file
*/
static void
-format_garmin_xt_proc_strk(void)
+format_garmin_xt_proc_strk()
{
int Count = 0; // Used to obtain number of read bytes
int NumberOfTracks = 0, TracksCompleted = 0; // Number of tracks in the file and number of processed tracks
}
static void
-format_garmin_xt_proc_atrk(void)
+format_garmin_xt_proc_atrk()
{
uint16_t block=0, uu=0;
uint32_t Lat=0, Lon=0;
}
static void
-format_garmin_xt_read(void)
+format_garmin_xt_read()
{
// Saved Tracks file
if (strcmp(opt_xt_ftype, "STRK") == 0) {
}
static QString
-gdb_fread_strlist(void)
+gdb_fread_strlist()
{
// char* res = NULL;
QString res;
/*-----------------------------------------------------------------------------*/
static void
-read_file_header(void)
+read_file_header()
{
char buf[128];
int i, reclen;
/*-----------------------------------------------------------------------------*/
static route_head*
-read_route(void)
+read_route()
{
route_head* rte;
int points, warnings, links, i;
/*-----------------------------------------------------------------------------*/
static route_head*
-read_track(void)
+read_track()
{
route_head* res;
int points, index;
}
static void
-gdb_rd_deinit(void)
+gdb_rd_deinit()
{
disp_summary(fin);
gdb_flush_waypt_queue(&wayptq_in);
}
static void
-read_data(void)
+read_data()
{
gbfile* fsave;
int incomplete = 0; /* number of incomplete reads */
/* ----------------------------------------------------------------------------*/
static void
-write_header(void)
+write_header()
{
char buff[128], tbuff[32];
char* c;
}
static void
-gdb_wr_deinit(void)
+gdb_wr_deinit()
{
disp_summary(fout);
gdb_flush_waypt_queue(&wayptq_out);
}
static void
-write_data(void)
+write_data()
{
if (gdb_opt_ver) {
gdb_ver = atoi(gdb_opt_ver);
}
static void
-geo_read(void)
+geo_read()
{
gpsbabel::File file(geo_read_fname);
file.open(QIODevice::ReadOnly);
}
static void
-geo_rd_deinit(void)
+geo_rd_deinit()
{
}
}
static void
-geo_wr_deinit(void)
+geo_wr_deinit()
{
writer.writeEndDocument();
gbfputs(ostring,ofd);
}
static void
-geo_write(void)
+geo_write()
{
writer.writeStartElement("loc");
writer.writeAttribute("version", "1.0");
}
static void
-geojson_wr_deinit(void) {
+geojson_wr_deinit() {
QJsonObject object;
object[TYPE] = FEATURE_COLLECTION;
object[FEATURES] = *feature_collection;
}
static void
-geojson_read(void) {
+geojson_read() {
QFile file;
file.setFileName(input_file_name);
file.open(QIODevice::ReadOnly | QIODevice::Text);
}
static void
-geojson_write(void) {
+geojson_write() {
waypt_disp_all(geojson_waypt_pr);
track_disp_all(geojson_track_hdr, geojson_track_tlr, geojson_track_disp);
}
}
static void
-ggv_bin_read_deinit(void)
+ggv_bin_read_deinit()
{
read_fname.clear();
}
static void
-ggv_bin_read(void)
+ggv_bin_read()
{
QFile file(read_fname);
}
static void
-ggv_log_rd_deinit(void)
+ggv_log_rd_deinit()
{
gbfclose(fin);
}
static void
-ggv_log_read(void)
+ggv_log_read()
{
signed char* buf;
int bufsz = 0, len;
}
static void
-ggv_log_wr_deinit(void)
+ggv_log_wr_deinit()
{
gbfclose(fout);
}
}
static void
-ggv_log_write(void)
+ggv_log_write()
{
track_disp_all(ggv_log_track_head_cb, NULL, NULL);
}
}
static void
-ggv_ovl_rd_deinit(void)
+ggv_ovl_rd_deinit()
{
inifile_done(inifile);
}
static void
-ggv_ovl_read(void)
+ggv_ovl_read()
{
int symbols;
int i;
static void waypt_disp_cb(const Waypoint* wpt);
static void track_disp_cb(const route_head* trk);
static void route_disp_cb(const route_head* rte);
-static void write_bounds(void);
+static void write_bounds();
static void draw_symbol_basics(const OVL_SYMBOL_TYP typ, const int art, const OVL_COLOR_TYP color, const Waypoint* wpt);
static int get_direction(const Waypoint* A, const Waypoint* B);
// static void draw_symbol_text(const char *text, const waypoint *reference);
}
static void
-ggv_ovl_wr_deinit(void)
+ggv_ovl_wr_deinit()
{
gbfclose(fout);
}
static void
-ggv_ovl_write(void)
+ggv_ovl_write()
{
group_ct = 1; /* tracks are not grouped */
color = OVL_COLOR_FUCHSIA;
}
static void
-write_bounds(void)
+write_bounds()
{
waypt_init_bounds(&all_bounds);
}
static void
-serial_deinit(void)
+serial_deinit()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " serial_deinit()\n");
static void
-rd_deinit(void)
+rd_deinit()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " rd_deinit()\n");
}
static void
-wr_deinit(void)
+wr_deinit()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " wr_deinit()\n");
serial_deinit();
}
-static void track_read(void);
+static void track_read();
static void
-waypoint_read(void)
+waypoint_read()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " waypoint_read()\n");
}
static void
-track_read(void)
+track_read()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " track_read()\n");
}
static void
-route_read(void)
+route_read()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " route_read() TODO\n");
}
static void
-data_read(void)
+data_read()
{
if (global_opts.debug_level > 1) {
printf(MYNAME " data_read()\n");
}
static void
-glogbook_read(void)
+glogbook_read()
{
xml_read();
}
static void
-glogbook_rd_deinit(void)
+glogbook_rd_deinit()
{
xml_deinit();
}
}
static void
-glogbook_wr_deinit(void)
+glogbook_wr_deinit()
{
writer.writeEndDocument();
gbfputs(ostring,ofd);
}
static void
-glogbook_write(void)
+glogbook_write()
{
#if 0
gbfprintf(ofd, "<?xml version=\"1.0\" ?>\n");
}
static void
-gnav_trl_rd_deinit(void)
+gnav_trl_rd_deinit()
{
gbfclose(fin);
}
static void
-gnav_trl_rw_deinit(void)
+gnav_trl_rw_deinit()
{
gbfclose(fout);
}
}
static void
-gnav_trl_read(void)
+gnav_trl_read()
{
route_head* trk = NULL;
}
static void
-gnav_trl_write(void)
+gnav_trl_write()
{
track_disp_all(NULL, NULL, gnav_trl_write_trkpt);
}
}
static void
-google_read(void)
+google_read()
{
xml_read();
}
static void
-google_rd_deinit(void)
+google_rd_deinit()
{
xml_deinit();
mkshort_del_handle(&desc_handle);
}
static void
-gopal_rd_deinit(void)
+gopal_rd_deinit()
{
gbfclose(fin);
}
static void
-gopal_read(void)
+gopal_read()
{
char* buff;
}
static void
-gopal_wr_deinit(void)
+gopal_wr_deinit()
{
gbfclose(fout);
}
static void
-gopal_write(void)
+gopal_write()
{
route_disp_all(gopal_route_hdr, gopal_route_tlr, gopal_write_waypt);
}
static void
-gopal_exit(void) /* optional */
+gopal_exit() /* optional */
{
}
}
static void
-gpssim_wr_deinit(void)
+gpssim_wr_deinit()
{
if (fout) {
gbfclose(fout);
}
static void
-gpssim_write(void)
+gpssim_write()
{
if (waypt_count()) {
if (splitfiles) {
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
}
static void
-data_read(void)
+data_read()
{
char* ibuf;
char desc[31];
}
static void
-data_write(void)
+data_write()
{
waypt_disp_all(gpsutil_disp);
}
* this allows gpx:wpt names to overlap gpx:rtept names, etc.
*/
static void
-gpx_reset_short_handle(void)
+gpx_reset_short_handle()
{
if (mkshort_handle != NULL) {
mkshort_del_handle(&mkshort_handle);
}
static void
-prescan_tags(void)
+prescan_tags()
{
tag_mapping* tm;
for (tm = tag_path_map; tm->tag_type_ != 0; tm++) {
static
void
-gpx_rd_deinit(void)
+gpx_rd_deinit()
{
delete reader;
reader = NULL;
}
static void
-gpx_wr_deinit(void)
+gpx_wr_deinit()
{
writer->writeEndDocument();
delete writer;
}
void
-gpx_read(void)
+gpx_read()
{
for (bool atEnd = false; !reader->atEnd() && !atEnd;) {
reader->readNext();
gpx_track_disp(const Waypoint* waypointp)
{
fs_xml* fs_gpx;
- int first_in_trk;
- first_in_trk = waypointp->Q.prev == ¤t_trk_head->waypoint_list;
+ bool first_in_trk = waypointp->Q.prev == ¤t_trk_head->waypoint_list;
if (waypointp->wpt_flags.new_trkseg) {
if (!first_in_trk) {
}
static void
-gpx_write_bounds(void)
+gpx_write_bounds()
{
waypt_init_bounds(&all_bounds);
}
static void
-gpx_write(void)
+gpx_write()
{
gpx_reset_short_handle();
static void
-gpx_free_gpx_global(void)
+gpx_free_gpx_global()
{
gpx_rm_from_global(&gpx_global->name);
gpx_rm_from_global(&gpx_global->desc);
}
static void
-gpx_exit(void)
+gpx_exit()
{
gpx_version.clear();
}
static void
-gtm_rd_deinit(void)
+gtm_rd_deinit()
{
gbfclose(file_in);
}
}
static void
-gtm_wr_deinit(void)
+gtm_wr_deinit()
{
gbfclose(file_out);
}
static void
-gtm_read(void)
+gtm_read()
{
route_head* first_trk_head = NULL;
route_head* trk_head = NULL;
}
static void
-gtm_write(void)
+gtm_write()
{
waypt_disp_all(write_waypt);
if (waypt_count()) {
}
static void
-gtc_read(void)
+gtc_read()
{
xml_read();
}
static void
-gtc_rd_deinit(void)
+gtc_rd_deinit()
{
xml_deinit();
}
}
static void
-gtc_wr_deinit(void)
+gtc_wr_deinit()
{
gbfclose(ofd);
}
}
static void
-gtc_fake_hdr(void)
+gtc_fake_hdr()
{
/* handle the CourseLap_t or the ActivityLap_t types. */
/* note that the elements must appear in the order required by the schema. */
}
void
-gtc_write(void)
+gtc_write()
{
gtc_write_xml(0, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n");
gtc_write_xml(1, "<TrainingCenterDatabase xmlns=\"http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2 http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd\">\n");
}
static void
-hiketech_read(void)
+hiketech_read()
{
xml_read();
}
static void
-hiketech_rd_deinit(void)
+hiketech_rd_deinit()
{
xml_deinit();
}
}
static void
-hiketech_wr_deinit(void)
+hiketech_wr_deinit()
{
writer.writeEndDocument();
gbfputs(ostring, ofd);
}
static void
-hiketech_write(void)
+hiketech_write()
{
writer.writeStartElement("hiketech");
writer.writeAttribute("version", "1.2");
}
-static void rd_deinit(void)
+static void rd_deinit()
{
gbfclose(file_in);
}
-static void wr_deinit(void)
+static void wr_deinit()
{
mkshort_del_handle(&mkshort_handle);
gbfclose(file_out);
-static void data_read(void)
+static void data_read()
{
char name[9], desc[90];
double lat,lon;
-static void data_write(void)
+static void data_write()
{
int iWritten;
short sCount;
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
}
static void
-data_write(void)
+data_write()
{
setshort_length(mkshort_handle, 6);
}
static void
-humminbird_rd_deinit(void)
+humminbird_rd_deinit()
{
gbfclose(fin);
}
}
static void
-humminbird_read(void)
+humminbird_read()
{
while (! gbfeof(fin)) {
uint32_t signature;
}
static void
-humminbird_wr_deinit(void)
+humminbird_wr_deinit()
{
mkshort_del_handle(&wptname_sh);
mkshort_del_handle(&rtename_sh);
static void
-humminbird_track_write(void)
+humminbird_track_write()
{
track_disp_all(humminbird_track_head, humminbird_track_tail, humminbird_track_cb);
}
static void
-humminbird_write(void)
+humminbird_write()
{
waypt_disp_all(humminbird_write_waypoint_wrapper);
route_disp_all(NULL, NULL, humminbird_write_waypoint_wrapper);
}
}
-static void rd_deinit(void)
+static void rd_deinit()
{
gbfclose(file_in);
}
route_add_wpt(rte_head, wpt);
}
-static void data_read(void)
+static void data_read()
{
char* ibuf;
igc_rec_type_t rec_type;
/*
* Write header records
*/
-static void wr_header(void)
+static void wr_header()
{
const route_head* pres_track;
const route_head* track;
}
}
-static void wr_tasks(void)
+static void wr_tasks()
{
route_disp_all(wr_task_hdr, wr_task_tlr, wr_task_wpt);
}
* Pressure altitude and GNSS altitude may be provided in two seperate
* tracks. This function attempts to merge them into one.
*/
-static void wr_track(void)
+static void wr_track()
{
const route_head* pres_track;
const route_head* gnss_track;
file_out = gbfopen(fname, "wb", MYNAME);
}
-static void wr_deinit(void)
+static void wr_deinit()
{
gbfclose(file_out);
}
-static void data_write(void)
+static void data_write()
{
gbfputs("AXXXZZZGPSBabel\r\n", file_out);
wr_header();
}
static void
-ignr_rd_deinit(void)
+ignr_rd_deinit()
{
xml_deinit();
}
static void
-ignr_read(void)
+ignr_read()
{
xml_read();
}
}
static void
-ignr_rw_deinit(void)
+ignr_rw_deinit()
{
gbfclose(fout);
}
}
static void
-ignr_write(void)
+ignr_write()
{
time_t now;
struct tm tm;
}
// Reader callback
-static void igo8_read(void)
+static void igo8_read()
{
Waypoint* wpt_tmp;
route_head* track_head;
}
// Reader close callback
-static void igo8_read_deinit(void)
+static void igo8_read_deinit()
{
gbfclose(igo8_file_in);
}
}
// Writer close callback
-static void igo8_write_deinit(void)
+static void igo8_write_deinit()
{
uint32_t normalized_file_size;
}
// Writer callback
-static void igo8_write(void)
+static void igo8_write()
{
write_header();
track_disp_all(NULL, NULL, write_igo8_track_point);
};
static void
-ikt_object_end(void)
+ikt_object_end()
{
if (track) {
track->rte_name = name;
}
static void
-ikt_read(void)
+ikt_read()
{
xml_read();
}
static void
-ikt_rd_deinit(void)
+ikt_rd_deinit()
{
ikt_object_end();
xml_deinit();
}
static gbfile*
-open_gpsbabel_inifile(void)
+open_gpsbabel_inifile()
{
char* name;
char* envstr;
}
static void
-itracku_rd_deinit(void)
+itracku_rd_deinit()
{
dbg(1, "%d new waypoints", new_waypoint_count);
if (fd) {
}
static void
-itracku_read_waypt(void)
+itracku_read_waypt()
{
itracku_waypt_input(&waypt_add);
}
}
static void
-itracku_read_trk(void)
+itracku_read_trk()
{
itracku_read_trk_track = route_head_alloc();
track_add_head(itracku_read_trk_track);
}
static void
-itracku_read(void)
+itracku_read()
{
switch (global_opts.objective) {
case wptdata:
}
static void
-itracku_wr_deinit(void)
+itracku_wr_deinit()
{
gbfclose(fout);
}
}
static void
-itracku_write(void)
+itracku_write()
{
waypt_disp_all(itracku_output_waypoint);
}
static void
-itracku_exit(void) /* optional */
+itracku_exit() /* optional */
{
}
}
static void
-itracku_rt_deinit(void)
+itracku_rt_deinit()
{
itracku_rd_deinit();
}
}
static void
-jogmap_read(void)
+jogmap_read()
{
xml_read();
}
static void
-jogmap_rd_deinit(void)
+jogmap_rd_deinit()
{
xml_deinit();
}
}
static void
-jtr_rd_deinit(void)
+jtr_rd_deinit()
{
trkpts.clear();
gbfclose(fin);
}
static void
-jtr_read(void)
+jtr_read()
{
char* str;
int line = 0;
}
static void
-jtr_wr_deinit(void)
+jtr_wr_deinit()
{
gbfclose(fout);
}
}
static void
-jtr_write(void)
+jtr_write()
{
track_disp_all(NULL, NULL, jtr_trkpt_disp_cb);
}
}
}
-static void kml_step_color(void)
+static void kml_step_color()
{
int color_seq;
// Map kml_color_sequencer.seq to an integer in the range [0, KML_COLOR_LIMIT*6).
static
void
-kml_read(void)
+kml_read()
{
xml_read();
}
static void
-kml_rd_deinit(void)
+kml_rd_deinit()
{
xml_deinit();
}
}
static void
-kml_wr_deinit(void)
+kml_wr_deinit()
{
writer->writeEndDocument();
delete writer;
}
static void
-kml_wr_position_deinit(void)
+kml_wr_position_deinit()
{
// kml_wr_deinit();
posnfilename.clear();
static
-void kml_gc_make_balloonstyletext(void)
+void kml_gc_make_balloonstyletext()
{
QString cdataStr;
}
static
-void kml_gc_make_balloonstyle(void)
+void kml_gc_make_balloonstyle()
{
// For Normal style of gecoaches, scale of label is set to zero
// to make the label invisible. On hover (highlight?) enlarge
// For Earth 5.0 and later, we write a LookAt that encompasses
// the bounding box of our entire data set and set the event times
// to include all our data.
-void kml_write_AbstractView(void)
+void kml_write_AbstractView()
{
double bb_size;
writer->writeEndElement(); // Close gx:SimpleArrayField tag
}
-void kml_write(void)
+void kml_write()
{
const global_trait* traits = get_traits();
}
static void
-lmx_wr_deinit(void)
+lmx_wr_deinit()
{
gbfclose(ofd);
}
static void
-lmx_write(void)
+lmx_write()
{
if (binary) {
gbfputc(0x03, ofd); // WBXML version 1.3
}
static void
-lmx_read(void)
+lmx_read()
{
xml_read();
}
static void
-lmx_rd_deinit(void)
+lmx_rd_deinit()
{
xml_deinit();
}
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
static void
-lowranceusr_parse_routes(void)
+lowranceusr_parse_routes()
{
char buff[MAXUSRSTRINGSIZE + 1];
short int num_routes, num_legs;
* option of ignoreicons is used
*/
static void
-lowranceusr_parse_icons(void)
+lowranceusr_parse_icons()
{
char buff[MAXUSRSTRINGSIZE + 1];
short int num_icons;
}
static void
-lowranceusr_parse_trails(void)
+lowranceusr_parse_trails()
{
char buff[MAXUSRSTRINGSIZE + 1];
short int num_trails, num_trail_points, num_section_points;
}
static void
-data_read(void)
+data_read()
{
short int NumWaypoints, MajorVersion, MinorVersion, object_num;
int i;
}
static void
-data_write(void)
+data_write()
{
short int NumWaypoints, MajorVersion, MinorVersion, NumRoutes, NumTrails, NumIcons;
setshort_length(mkshort_handle, 15);
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
static
lowranceusr4_fsdata*
-lowranceusr4_alloc_fsdata(void)
+lowranceusr4_alloc_fsdata()
{
lowranceusr4_fsdata* fsdata = (lowranceusr4_fsdata*) xcalloc(sizeof(*fsdata), 1);
fsdata->fs.type = FS_LOWRANCEUSR4;
static void
-lowranceusr4_parse_waypoints(void)
+lowranceusr4_parse_waypoints()
{
short int icon_num;
unsigned int i, num_waypts, create_date, create_time;
}
static void
-lowranceusr4_parse_routes(void)
+lowranceusr4_parse_routes()
{
unsigned int num_routes, i, j, text_len;
unsigned int num_legs;
}
static void
-lowranceusr4_parse_trails(void)
+lowranceusr4_parse_trails()
{
int num_trails, num_trail_pts, M, i, j, k, trk_num, text_len;
char buff[MAXUSRSTRINGSIZE + 1];
static void
-data_read(void)
+data_read()
{
short int MajorVersion, MinorVersion;
int text_len, DataStreamVersion;
}
static void
-lowranceusr4_write_waypoints(void)
+lowranceusr4_write_waypoints()
{
int i;
}
static void
-lowranceusr4_write_routes(void)
+lowranceusr4_write_routes()
{
if (global_opts.debug_level >= 1) {
printf(MYNAME " writing %d routes\n", route_count());
}
static void
-lowranceusr4_write_trails(void)
+lowranceusr4_write_trails()
{
if (global_opts.debug_level >= 1) {
printf(MYNAME " writing %d tracks\n", track_count());
}
static void
-data_write(void)
+data_write()
{
short int MajorVersion, MinorVersion;
int DataStreamVersion;
}
static void
-maggeo_rd_deinit(void)
+maggeo_rd_deinit()
{
gbfclose(maggeofile_in);
}
}
static void
-maggeo_wr_deinit(void)
+maggeo_wr_deinit()
{
maggeo_writemsg("PMGNCMD,END");
mkshort_del_handle(&desc_handle);
}
static void
-maggeo_read(void)
+maggeo_read()
{
char* buff;
}
static void
-maggeo_write(void)
+maggeo_write()
{
waypt_disp_all(maggeo_waypt_pr);
}
static QString termread(char* ibuf, int size);
static void termwrite(char* obuf, int size);
static void mag_readmsg(gpsdata_type objective);
-static void mag_handon(void);
-static void mag_handoff(void);
+static void mag_handon();
+static void mag_handoff();
static short_handle mkshort_handle = NULL;
static char* deficon = NULL;
static char* bs = NULL;
}
static void
-mag_handon(void)
+mag_handon()
{
if (!is_file) {
mag_writemsg("PMGNCMD,HANDON");
}
static void
-mag_handoff(void)
+mag_handoff()
{
if (!is_file) {
mag_writemsg("PMGNCMD,HANDOFF");
}
static void
-mag_deinit(void)
+mag_deinit()
{
if (explorist_info) {
explorist_ini_done(explorist_info);
}
static void
-mag_wr_deinit(void)
+mag_wr_deinit()
{
if (explorist) {
mag_writemsg("PMGNCMD,END");
}
static void
-mag_read(void)
+mag_read()
{
if (gpx_vec) {
char** f = os_gpx_files(explorist_info->track_path);
}
static void
-mag_write(void)
+mag_write()
{
wptcmtcnt = 0;
}
static void
-print_extended_info(void)
+print_extended_info()
{
printf(
}
static void
-tr7_read(void)
+tr7_read()
{
route_head* trk = NULL;
unsigned int magic;
}
static void
-tr7_rd_deinit(void)
+tr7_rd_deinit()
{
track_disp_session(curr_session(),
tr7_check_after_read_head_cb,
}
static void
-tr7_wr_deinit(void)
+tr7_wr_deinit()
{
gbfclose(fout);
}
static void
-tr7_write(void)
+tr7_write()
{
track_disp_all(tr7_disp_track_head_cb, NULL, tr7_disp_waypt_cb);
}
}
static void
-mapbar_track_rd_deinit(void)
+mapbar_track_rd_deinit()
{
gbfclose(fin);
}
static gpsbabel::DateTime
-read_datetime(void)
+read_datetime()
{
int hour = gbfgetint16(fin);
int min = gbfgetint16(fin);
static const double DIV_RATE = 100000.0f;
static Waypoint*
-read_waypoint(void)
+read_waypoint()
{
int longitude = gbfgetint32(fin);
int latitude = gbfgetint32(fin);
}
static void
-mapbar_track_read(void)
+mapbar_track_read()
{
route_head* track = route_head_alloc();
is_fatal((track == NULL), MYNAME ": memory non-enough");
}
static void
-mapfactor_read(void)
+mapfactor_read()
{
gpsbabel::File file(mapfactor_read_fname);
file.open(QIODevice::ReadOnly);
static void
-mapfactor_rd_deinit(void)
+mapfactor_rd_deinit()
{
}
}
static void
-mapfactor_wr_deinit(void)
+mapfactor_wr_deinit()
{
writer->writeEndDocument();
delete writer;
}
static void
-mapfactor_write(void)
+mapfactor_write()
{
writer->writeStartElement("favourites");
writer->writeAttribute("version", "1");
}
static void
-mapsend_rd_deinit(void)
+mapsend_rd_deinit()
{
gbfclose(mapsend_file_in);
}
}
static void
-mapsend_wr_deinit(void)
+mapsend_wr_deinit()
{
gbfclose(mapsend_file_out);
mkshort_del_handle(&mkshort_handle);
}
static void
-mapsend_wpt_read(void)
+mapsend_wpt_read()
{
char tbuf[256];
int wpt_count, rte_count, rte_num;
}
static void
-mapsend_track_read(void)
+mapsend_track_read()
{
unsigned int trk_count;
int valid;
}
static void
-mapsend_read(void)
+mapsend_read()
{
mapsend_hdr hdr;
int type;
}
void
-mapsend_track_write(void)
+mapsend_track_write()
{
track_disp_all(mapsend_track_hdr, mapsend_noop, mapsend_track_disp);
}
static void
-mapsend_wpt_write(void)
+mapsend_wpt_write()
{
mapsend_hdr hdr = {13, {'4','D','5','3','3','3','3','0',' ','M','S'},
{'3', '0'}, ms_type_wpt, {0, 0, 0}
}
static void
-mps_rd_deinit(void)
+mps_rd_deinit()
{
gbfclose(mps_file_in);
if (read_route_wpt_mkshort_handle) {
}
static void
-mps_wr_deinit(void)
+mps_wr_deinit()
{
gbfclose(mps_file_out);
static void
-mps_read(void)
+mps_read()
{
Waypoint* wpt;
route_head* rte;
}
void
-mps_write(void)
+mps_write()
{
int short_length;
Waypoint* wpt;
#endif
static char*
-mmo_readstr(void)
+mmo_readstr()
{
char* res;
signed int len;
}
-static mmo_data_t* mmo_read_object(void);
+static mmo_data_t* mmo_read_object();
static void
static mmo_data_t*
-mmo_read_object(void)
+mmo_read_object()
{
int objid;
mmo_data_t* data = NULL;
static void
-mmo_rd_deinit(void)
+mmo_rd_deinit()
{
route_disp_session(curr_session(), NULL, NULL, mmo_finalize_rtept_cb);
static void
-mmo_read(void)
+mmo_read()
{
#ifdef MMO_DBG
const char* sobj = "main";
static void
-mmo_wr_deinit(void)
+mmo_wr_deinit()
{
mmobjects.clear();
category_names.clear();
static void
-mmo_write(void)
+mmo_write()
{
int i;
};
static void mtk_locus_rd_init(const QString& fname);
-static void mtk_locus_rd_deinit(void);
-static void mtk_locus_read(void);
+static void mtk_locus_rd_deinit();
+static void mtk_locus_read();
ff_vecs_t mtk_locus_vecs = {
ff_type_file,
static char waiting_for[20];
-static void set_baudrate(void);
-static void read_line(void);
-static void process_packet(void);
-static void process_pmtklox(void);
-static void process_pmtklog(void);
-static void process_pmtk001(void);
-static void process_pmtk705(void);
+static void set_baudrate();
+static void read_line();
+static void process_packet();
+static void process_pmtklox();
+static void process_pmtklog();
+static void process_pmtk001();
+static void process_pmtk705();
static void send_command(const char* s, const char* waitfor);
static int calculate_checksum(const char* s, int length);
static void dbg(int l, const char* msg, ...);
}
static void
-mtk_locus_rd_deinit(void)
+mtk_locus_rd_deinit()
{
if (read_mode == rm_serial) {
gbser_deinit(sfd);
}
static void
-mtk_locus_read(void)
+mtk_locus_read()
{
int i;
}
void
-read_line(void)
+read_line()
{
int rc;
char* s;
static int mtk_log_len(unsigned int bitmask);
static void mtk_rd_init(const QString& fname);
static void file_init(const QString& fname);
-static void file_deinit(void) ;
-static void holux245_init(void);
-static void file_read(void);
+static void file_deinit() ;
+static void holux245_init();
+static void file_read();
static int mtk_parse_info(const unsigned char* data, int dataLen);
xfree(model);
}
-static void mtk_rd_deinit(void)
+static void mtk_rd_deinit()
{
if (mtk_device == HOLUX_GR245) {
int rc = do_cmd("$PHLX827*31\r\n", "PHLX860*32", NULL, 10);
xfree(port);
}
-static int mtk_erase(void)
+static int mtk_erase()
{
int log_status, log_mask, err;
char* lstatus = NULL;
return 0;
}
-static void mtk_read(void)
+static void mtk_read()
{
char cmd[256];
char* line = NULL;
gbfprintf(cd, "\n");
}
-static void mtk_csv_deinit(void)
+static void mtk_csv_deinit()
{
if (cd != NULL) {
gbfclose(cd);
}
}
-static void file_deinit(void)
+static void file_deinit()
{
dbg(4, "Closing file...\n");
fclose(fl);
}
-static void holux245_init(void)
+static void holux245_init()
{
mtk_device = HOLUX_GR245;
return 0;
}
-static void file_read(void)
+static void file_read()
{
long fsize, pos;
int i, j, k, bLen;
}
static void
-mynav_rd_deinit(void)
+mynav_rd_deinit()
{
gbfclose(fin);
}
static void
-mynav_rd(void)
+mynav_rd()
{
QString buff;
}
static void
-nav_read(void)
+nav_read()
{
QXmlStreamReader reader;
gpsbabel::File file(read_fname);
}
static void
-nav_rd_deinit(void)
+nav_rd_deinit()
{
}
}
static void
-nav_wr_deinit(void)
+nav_wr_deinit()
{
}
static void
-nav_write(void)
+nav_write()
{
}
/* Forward declarations */
-static void ng_read_file_header(void);
+static void ng_read_file_header();
static
arglist_t ng_args[] = {
/* =================== Write data functions ====================================*/
static void
-ng_fill_header_default(void)
+ng_fill_header_default()
{
ng_file_header_t default_header = {
0x00,
static void
-ng_fill_waypoint_default(void)
+ng_fill_waypoint_default()
{
ng_wp_data_t default_wp = {
{0xfe, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00},
}
static void
-header_write(void)
+header_write()
{
ng_file_header.nof_wp = nof_wp;
gbfputint16(nof_wp, file_out);
static void
-data_write(void)
+data_write()
{
nof_wp = waypt_count();
if (nof_wp) {
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
file_in = NULL;
static void
-ng_read_file_header(void)
+ng_read_file_header()
{
nof_wp = gbfgetint16(file_in);
}
static void
-data_read(void)
+data_read()
{
if (process_rte) {
rte_head = route_head_alloc();
}
static unsigned
-read_word(void)
+read_word()
{
unsigned char buffer[2];
}
static Waypoint**
-serial_read_waypoints(void)
+serial_read_waypoints()
{
Waypoint** waypts = NULL;
unsigned char information[32];
}
static void
-serial_read_track(void)
+serial_read_track()
{
unsigned char information[32];
unsigned int address;
}
static void
-serial_write_track(void)
+serial_write_track()
{
unsigned char information[32];
unsigned int address;
}
static void
-serial_read_datalog(void)
+serial_read_datalog()
{
route_head* track;
unsigned int seg1_addr;
}
static void
-file_read(void)
+file_read()
{
unsigned char data[32];
route_head* track = NULL;
}
static void
-nuke(void)
+nuke()
{
if (nuketrk) {
unsigned char information[32];
}
static void
-navilink_deinit(void)
+navilink_deinit()
{
if (serial_handle) {
/* nuke data after reading */
}
static void
-navilink_read(void)
+navilink_read()
{
if (datalog) {
if (global_opts.masked_objective & TRKDATAMASK) {
}
static void
-navilink_write(void)
+navilink_write()
{
if (datalog) {
fatal(MYNAME ": Writing to datalog not supported.\n");
}
static void
-navitel_rd_deinit(void)
+navitel_rd_deinit()
{
gbfclose(fin);
}
static void
-navitel_read_track(void)
+navitel_read_track()
{
int points, i;
route_head* trk = NULL;
}
static void
-navitel_wr_deinit(void)
+navitel_wr_deinit()
{
gbfclose(fout);
}
}
static void
-navitel_write_track(void)
+navitel_write_track()
{
trkpts = 0;
track_disp_all(NULL, NULL, navitel_enum_trkpts);
static char* snmac = NULL;
static int macstumbler;
-static void fix_netstumbler_dupes(void);
+static void fix_netstumbler_dupes();
#define MYNAME "NETSTUMBLER"
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
static void
-data_read(void)
+data_read()
{
char* ibuf;
char ssid[2 + 32 + 2 + 1]; /* "( " + SSID + " )" + null */
static
void
-fix_netstumbler_dupes(void)
+fix_netstumbler_dupes()
{
int i, ct = waypt_count(), serial = 0;
htable_t* htable, *bh;
}
static void
-nmea_rd_deinit(void)
+nmea_rd_deinit()
{
switch (read_mode) {
case rm_serial:
}
static void
-nmea_wr_deinit(void)
+nmea_wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
}
static void
-nmea_read(void)
+nmea_read()
{
char* ibuf;
char* ck;
static void reset_sirf_to_nmea(int br);
static
-int hunt_sirf(void)
+int hunt_sirf()
{
/* Try to place the common BR's first to speed searching */
static int br[] = {38400, 9600, 57600, 115200, 19200, 4800, -1};
}
static void
-nmea_write(void)
+nmea_write()
{
waypt_disp_all(nmea_wayptpr);
track_disp_all(nmea_track_init, NULL, nmea_trackpt_pr);
}
static void
-nmea_wr_posn_deinit(void)
+nmea_wr_posn_deinit()
{
// nmea_wr_deinit();
}
}
static void
-nmn4_read_data(void)
+nmn4_read_data()
{
char* buff;
char* str;
}
static void
-nmn4_write_data(void)
+nmn4_write_data()
{
target_rte_num = 1;
}
static void
-nmn4_rd_deinit(void)
+nmn4_rd_deinit()
{
gbfclose(fin);
}
static void
-nmn4_read(void)
+nmn4_read()
{
nmn4_read_data();
}
}
static void
-nmn4_wr_deinit(void)
+nmn4_wr_deinit()
{
gbfclose(fout);
}
static void
-nmn4_write(void)
+nmn4_write()
{
nmn4_write_data();
}
/*-----------------------------------------------------------------------------*/
static void
-osm_features_init(void)
+osm_features_init()
{
int i;
}
static void
-osm_read(void)
+osm_read()
{
xml_read();
}
static void
-osm_rd_deinit(void)
+osm_rd_deinit()
{
xml_deinit();
waypoints.clear();
/*-----------------------------------------------------------------------------*/
static void
-osm_init_icons(void)
+osm_init_icons()
{
int i;
}
static void
-osm_write(void)
+osm_write()
{
gbfprintf(fout, "<?xml version='1.0' encoding='UTF-8'?>\n");
gbfprintf(fout, "<osm version='0.6' generator='GPSBabel");
}
static void
-osm_wr_deinit(void)
+osm_wr_deinit()
{
gbfclose(fout);
}
static void
-osm_exit(void)
+osm_exit()
{
keys.clear();
values.clear();
static
ozi_fsdata*
-ozi_alloc_fsdata(void)
+ozi_alloc_fsdata()
{
ozi_fsdata* fsdata = (ozi_fsdata*) xcalloc(sizeof(*fsdata), 1);
fsdata->fs.type = FS_OZI;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
file_in = NULL;
}
static void
-wr_deinit(void)
+wr_deinit()
{
if (file_out != NULL) {
}
static void
-data_read(void)
+data_read()
{
QString buff;
char* trk_name = NULL;
}
static void
-data_write(void)
+data_write()
{
static const char* ozi_wpt_header =
"OziExplorer Waypoint File Version 1.1\r\n"
file_in = gbfopen(fname, "rb", MYNAME);
}
-static void rd_deinit(void) { gbfclose(file_in); }
+static void rd_deinit() { gbfclose(file_in); }
static void wr_init(const QString& fname) {
file_out = gbfopen(fname, "w", MYNAME);
mkshort_handle2 = mkshort_new_handle();
}
-static void wr_deinit(void) {
+static void wr_deinit() {
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
mkshort_del_handle(&mkshort_handle2);
// to allow fields in any order and length, based on their position in
// these header lines. Oddly, we've seen only 'W' records take this form.
-static void data_read(void) {
+static void data_read() {
int symnum;
Waypoint* wpt_tmp;
char* buff;
wpt->altitude);
}
-static void data_write(void) {
+static void data_write() {
gbfprintf(file_out,
"H SOFTWARE NAME & VERSION\n"
"I PCX5 2.09\n"
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
static void
-read_tracks(void)
+read_tracks()
{
struct breadcrumb bc;
route_head* trk_head = route_head_alloc();
}
static void
-data_read(void)
+data_read()
{
read_tracks();
}
static void
-data_write(void)
+data_write()
{
track_disp_all(route_head_noop, route_head_noop, pocketfms_waypt_disp);
}
}
static void
-data_read(void)
+data_read()
{
xml_read();
}
static void
-rd_deinit(void)
+rd_deinit()
{
if (route != NULL) {
Waypoint* head = (Waypoint*) QUEUE_FIRST(&route->waypoint_list);
}
static void
-data_read(void)
+data_read()
{
char* buff;
int linecount = 0;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-data_write(void)
+data_write()
{
waypt_disp_all(enigma_waypt_disp);
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
}
static void
-psit_rd_deinit(void)
+psit_rd_deinit()
{
gbfclose(psit_file_in);
}
}
static void
-psit_wr_deinit(void)
+psit_wr_deinit()
{
gbfclose(psit_file_out);
}
static void
-psit_read(void)
+psit_read()
{
Waypoint* wpt;
route_head* rte;
}
void
-psit_write(void)
+psit_write()
{
int short_length;
}
static void
-random_rd_deinit(void)
+random_rd_deinit()
{
}
static void
-random_read(void)
+random_read()
{
#define RND(a) (rand_int(a) > 0)
}
static void
-raymarine_rd_done(void)
+raymarine_rd_done()
{
inifile_done(fin);
}
static void
-raymarine_read(void)
+raymarine_read()
{
Waypoint* wpt;
unsigned int ix;
}
static short_handle
-raymarine_new_short_handle(void)
+raymarine_new_short_handle()
{
short_handle res;
}
static void
-raymarine_wr_done(void)
+raymarine_wr_done()
{
mkshort_del_handle(&hshort_wpt);
mkshort_del_handle(&hshort_rte);
}
static void
-raymarine_write(void)
+raymarine_write()
{
int i;
Waypoint* wpt;
extern void update_common_traits(const Waypoint* wpt);
void
-route_init(void)
+route_init()
{
QUEUE_INIT(&my_route_head);
QUEUE_INIT(&my_track_head);
}
unsigned int
-route_waypt_count(void)
+route_waypt_count()
{
/* total wapoint count -- all routes */
return rte_waypts;
}
unsigned int
-route_count(void)
+route_count()
{
return rte_head_ct; /* total # of routes */
}
unsigned int
-track_waypt_count(void)
+track_waypt_count()
{
/* totaly waypoint count -- all tracks */
return trk_waypts;
}
unsigned int
-track_count(void)
+track_count()
{
return trk_head_ct; /* total # of tracks */
}
route_head*
-route_head_alloc(void)
+route_head_alloc()
{
route_head* rte_head = new route_head;
return rte_head;
}
void
-route_flush_all_routes(void)
+route_flush_all_routes()
{
route_flush_q(&my_route_head);
rte_head_ct = 0;
}
void
-route_flush_all_tracks(void)
+route_flush_all_tracks()
{
route_flush_q(&my_track_head);
trk_head_ct = 0;
}
static void
-common_restore_finish(void)
+common_restore_finish()
{
rte_head_ct = 0;
trk_head_ct = 0;
* at all to "fix" anything in the process.
*/
void
-routes_to_tracks(void)
+routes_to_tracks()
{
queue* elem, *tmp;
* Same, but in opposite direction.
*/
void
-tracks_to_routes(void)
+tracks_to_routes()
{
queue* elem, *tmp;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(infile);
}
static void
-my_read(void)
+my_read()
{
uint16_t version;
}
static void
-sbn_rd_deinit(void)
+sbn_rd_deinit()
{
gbfclose(file_handle);
}
static void
-sbn_read(void)
+sbn_read()
{
if (global_opts.masked_objective & TRKDATAMASK) {
route_head* track;
}
static void
-sbn_exit(void)
+sbn_exit()
{
}
}
static void
-sbp_rd_deinit(void)
+sbp_rd_deinit()
{
gbfclose(file_handle);
}
}
static Waypoint*
-read_logpoint(void)
+read_logpoint()
{
unsigned char buffer[SBP_RECORD_LEN];
}
static void
-sbp_read(void)
+sbp_read()
{
Waypoint* logpoint;
route_head* track;
}
static void
-sbp_exit(void)
+sbp_exit()
{
}
static void session_free(session_t* s);
void
-session_init(void)
+session_init()
{
QUEUE_INIT(&session_list);
session_ct = 0;
}
void
-session_exit(void)
+session_exit()
{
queue* elem, *tmp;
}
session_t*
-curr_session(void)
+curr_session()
{
return (session_t*) session_list.prev;
}
static void
-skyforce_rd_deinit(void)
+skyforce_rd_deinit()
{
gbfclose(fin);
}
static void
-skyforce_read(void)
+skyforce_read()
{
char* str;
route_head* rte, *trk;
static void
-skyforce_wr_deinit(void)
+skyforce_wr_deinit()
{
mkshort_del_handle(&short_h);
gbfclose(fout);
static void
-skyforce_write(void)
+skyforce_write()
{
switch (global_opts.objective) { /* We can only write one data type at a time */
}
static void
-rd_drain(void)
+rd_drain()
{
if (gbser_flush(serial_handle)) {
db(1, MYNAME ": rd_drain(): Comm error\n");
}
static unsigned int
-rd_word(void)
+rd_word()
{
int errors = 5; /* allow this many errors */
uint8_t buffer[2];
}
static int
-skytraq_system_restart(void)
+skytraq_system_restart()
{
uint8_t MSG_SYSTEM_RESTART[15] =
{ 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
}
static int
-skytraq_configure_logging(void)
+skytraq_configure_logging()
{
// an0008-1.4.14: logs if
// (dt > tmin & dd >= dmin & v >= vmin) | dt > tmax | dd > dmax | v > vmax
}
static void
-skytraq_read_tracks(void)
+skytraq_read_tracks()
{
struct read_state st;
uint32_t log_wr_ptr;
}
static int
-skytraq_probe(void)
+skytraq_probe()
{
int baud_rates[] = { 9600, 230400, 115200, 57600, 4800, 19200, 38400 };
int baud_rates_count = sizeof(baud_rates)/sizeof(baud_rates[0]);
}
static void
-skytraq_set_location(void)
+skytraq_set_location()
{
double lat, lng;
unsigned int i;
}
static void
-skytraq_rd_deinit(void)
+skytraq_rd_deinit()
{
gbser_deinit(serial_handle);
serial_handle = NULL;
}
static void
-skytraq_read(void)
+skytraq_read()
{
int dlbaud;
}
static void
-file_deinit(void)
+file_deinit()
{
db(1, "Closing file...\n");
gbfclose(file_handle);
}
static void
-file_read(void)
+file_read()
{
struct read_state st;
int rc, got_bytes;
mhport=fname;
}
static void
-miniHomer_rd_deinit(void)
+miniHomer_rd_deinit()
{
skytraq_rd_deinit();
mhport.clear();
}
#define SETPOI(poinum, poiname) if (opt_set_poi_##poiname ) {miniHomer_set_poi(poinum, opt_set_poi_##poiname);}
static void
-miniHomer_read(void)
+miniHomer_read()
{
int npoi=0;
/*
}
void
-routesimple_process(void)
+routesimple_process()
{
waypt_del_fnp = route_del_wpt;
route_disp_all(routesimple_head, routesimple_tail, routesimple_waypt_pr);
}
void
-routesimple_deinit(void)
+routesimple_deinit()
{
/* do nothing */
}
}
static void
-subrip_wr_deinit(void)
+subrip_wr_deinit()
{
gbfclose(fout);
}
static void
-subrip_write(void)
+subrip_write()
{
track_disp_all(NULL, NULL, subrip_trkpt_pr);
}
static void
-tef_xml_read(void)
+tef_xml_read()
{
xml_read();
}
static void
-tef_xml_rd_deinit(void)
+tef_xml_rd_deinit()
{
xml_deinit();
}
}
static void
-teletype_rd_deinit(void)
+teletype_rd_deinit()
{
gbfclose(fin);
}
static void
-teletype_read(void)
+teletype_read()
{
uint32_t i;
for (i = 0; i < tty_wpt_count; i++) {
}
static void
-teletype_exit(void) /* optional */
+teletype_exit() /* optional */
{
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
if (!split_output) {
gbfclose(file_out);
}
static void
-data_write(void)
+data_write()
{
if (! suppresssep && !split_output) {
gbfprintf(file_out, "-----------------------------------------------------------------------------\n");
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
mkshort_del_handle(&mkshort_handle);
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
static void
-data_read(void)
+data_read()
{
double lat,lon;
char desc[101];
}
static void
-data_write(void)
+data_write()
{
double latsz,lonsz;
maxlat = -9999.0;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
static void
-data_read(void)
+data_read()
{
char* buff;
char* s;
}
static void
-data_write(void)
+data_write()
{
/* Short names */
if (global_opts.synthesize_shortnames) {
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(file_in);
}
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
}
}
static void
-data_read(void)
+data_read()
{
int rectype;
long recsize;
}
static void
-data_write(void)
+data_write()
{
int ct = waypt_count();
struct hdr* htable, *bh;
+++ /dev/null
-# cvs log -b -N -d '>2003-09-22' | less +date
}
static void
-tpg_common_init(void)
+tpg_common_init()
{
tpg_datum_idx = GPS_Lookup_Datum_Index(tpg_datum_opt);
if (tpg_datum_idx < 0) {
}
static void
-tpg_rd_deinit(void)
+tpg_rd_deinit()
{
gbfclose(tpg_file_in);
}
}
static void
-tpg_wr_deinit(void)
+tpg_wr_deinit()
{
mkshort_del_handle(&mkshort_handle);
gbfclose(tpg_file_out);
}
static void
-tpg_read(void)
+tpg_read()
{
char buff[MAXTPGSTRINGSIZE + 1];
Waypoint* wpt_tmp;
}
static void
-tpg_write(void)
+tpg_write()
{
int s;
unsigned char header_bytes[] = { 0xFF, 0xFF, 0x01, 0x00, 0x0D,
// that is the only type of data available in the version 2.x TPO
// files.
//
-void tpo_read_2_x(void)
+void tpo_read_2_x()
{
char buff[16];
short track_count, waypoint_count;
// Track decoder for version 3.x files. This block contains tracks
// (called "freehand routes" or just "routes" in Topo).
//
-void tpo_process_tracks(void)
+void tpo_process_tracks()
{
unsigned int track_count, track_style_count;
unsigned int xx,ii,tmp;
// Waypoint decoder for version 3.x files.
//
-void tpo_process_waypoints(void)
+void tpo_process_waypoints()
{
unsigned int waypoint_count;
unsigned int ii;
// Map Notes decoder for version 3.x files.
//
-void tpo_process_map_notes(void)
+void tpo_process_map_notes()
{
unsigned int waypoint_count;
unsigned int ii;
// Symbols decoder for version 3.x files.
//
-void tpo_process_symbols(void)
+void tpo_process_symbols()
{
unsigned int waypoint_count;
unsigned int ii;
// Text Labels decoder for version 3.x files.
//
-void tpo_process_text_labels(void)
+void tpo_process_text_labels()
{
unsigned int waypoint_count;
unsigned int ii;
// with pointers to waypoint objects by tpo_process_waypoints()
// function above.
//
-void tpo_process_routes(void)
+void tpo_process_routes()
{
unsigned int route_count;
unsigned int ii;
// Compass decoder for version 3.x files.
//
-void tpo_process_compass(void)
+void tpo_process_compass()
{
// Not implemented yet
// (called "freehand routes" or just "routes" in Topo), "waypoints",
// and "gps-routes". We intend to read all three types.
//
-void tpo_read_3_x(void)
+void tpo_read_3_x()
{
if (doing_trks) {
}
static void
-tpo_rd_deinit(void)
+tpo_rd_deinit()
{
unsigned int i;
}
static void
-tpo_read(void)
+tpo_read()
{
if (tpo_version == 2.0) {
}
static void
-tpo_wr_deinit(void)
+tpo_wr_deinit()
{
/* the file footer is six bytes of zeroes */
unsigned char file_footer_bytes[6];
}
static void
-tpo_write(void)
+tpo_write()
{
unsigned char unknown1[] = { 0xFF, 0xFF, 0x01, 0x00 };
}
static void
-unicsv_rd_deinit(void)
+unicsv_rd_deinit()
{
gbfclose(fin);
unicsv_fields_tab.clear();
}
static void
-unicsv_rd(void)
+unicsv_rd()
{
char* buff;
}
static void
-unicsv_wr_deinit(void)
+unicsv_wr_deinit()
{
gbfclose(fout);
}
static void
-unicsv_wr(void)
+unicsv_wr()
{
switch (global_opts.objective) {
case wptdata:
* reference files would be tedious, so we uphold that convention.
*/
gpsbabel::DateTime
-current_time(void)
+current_time()
{
if (getenv("GPSBABEL_FREEZE_TIME")) {
return QDateTime::fromTime_t(0);
}
static void
-v900_rd_deinit(void)
+v900_rd_deinit()
{
v900_log("%s\n",__func__);
if (fin) {
}
static void
-v900_read(void)
+v900_read()
{
/* use line buffer large enough to hold either basic or advanced mode lines. */
union {
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(file_out);
mkshort_del_handle(&mkshort_handle);
}
static void
-data_write(void)
+data_write()
{
setshort_length(mkshort_handle, 6);
waypt_disp_all(vcf_disp);
};
void
-init_vecs(void)
+init_vecs()
{
vecs_t* vec = vec_list;
while (vec->vec) {
}
void
-exit_vecs(void)
+exit_vecs()
{
vecs_t* vec = vec_list;
while (vec->vec) {
#define VEC_FMT " %-20.20s %-.50s\n"
void
-disp_vecs(void)
+disp_vecs()
{
vecs_t** svp;
arglist_t* ap;
}
static void
-vidaone_rd_deinit(void)
+vidaone_rd_deinit()
{
gbfclose(fin);
}
static void
-vidaone_read(void)
+vidaone_read()
{
route_head* trk = NULL;
}
static void
-vidaone_wr_deinit(void)
+vidaone_wr_deinit()
{
gbfclose(fout);
}
}
static void
-vidaone_write(void)
+vidaone_write()
{
track_disp_all(NULL, NULL, vidaone_trkpt);
}
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(infile);
}
static void
-vitosmt_read(void)
+vitosmt_read()
{
long version =0;
long subversion =0;
}
static void
-wr_deinit(void)
+wr_deinit()
{
gbfclose(ofs);
static void
-vitosmt_write(void)
+vitosmt_write()
{
unsigned char* workbuffer =0;
size_t position =0;
}
static void
-rd_deinit(void)
+rd_deinit()
{
gbfclose(infile);
}
static void
-vitovtt_read(void)
+vitovtt_read()
{
int version = 0;
route_head* route_head = 0;
}
static void
-vpl_rd_deinit(void)
+vpl_rd_deinit()
{
gbfclose(vpl_file_in);
}
static void
-vpl_read(void)
+vpl_read()
{
char* ibuf;
geocache_data Waypoint::empty_gc_data;
static global_trait traits;
-const global_trait* get_traits(void)
+const global_trait* get_traits()
{
return &traits;
}
void
-waypt_init(void)
+waypt_init()
{
mkshort_handle = mkshort_new_handle();
#if NEWQ
}
unsigned int
-waypt_count(void)
+waypt_count()
{
#if NEWQ
return waypt_list.size();
}
}
-static void rd_deinit(void)
+static void rd_deinit()
{
db(1, "Closing port...\n");
gbser_deinit(fd);
}
}
-static void file_deinit(void)
+static void file_deinit()
{
db(1, "Closing file...\n");
fclose(fl);
return 1;
}
-static void wbt200_data_read(void)
+static void wbt200_data_read()
{
/* Awooga! Awooga! Statically allocated buffer danger!
* Actually, it's OK because rd_line can read arbitrarily
}
-static void wbt201_data_read(void)
+static void wbt201_data_read()
{
char line_buf[100];
struct read_state st;
do_simple("@AL,2,1", BUFSPEC(line_buf));
}
-static void file_read(void)
+static void file_read()
{
char buf[512];
size_t rc;
state_empty(&st);
}
-static void data_read(void)
+static void data_read()
{
switch (dev_type) {
case WBT200:
}
void
-wfff_xml_read(void)
+wfff_xml_read()
{
xml_read();
}
void
-wfff_xml_rd_deinit(void)
+wfff_xml_rd_deinit()
{
xml_deinit();
}
static void
-wintec_tes_rd_deinit(void)
+wintec_tes_rd_deinit()
{
gbfclose(fin);
}
}
static void
-wintec_tes_read(void)
+wintec_tes_read()
{
route_head* trk = route_head_alloc();
track_add_head(trk);
}
void
-xml_deinit(void)
+xml_deinit()
{
reader_data.clear();
rd_fname.clear();
}
}
-void xml_read(void)
+void xml_read()
{
gpsbabel::File file(rd_fname);
QString current_tag;
xml_init(fname, xol_map, NULL);
}
-static void xol_read(void) { xml_read(); }
+static void xol_read() { xml_read(); }
-static void xol_rd_deinit(void) { xml_deinit(); }
+static void xol_rd_deinit() { xml_deinit(); }
/* writer */
setshort_defname(short_h, "Waypoint");
}
-static void xol_wr_deinit(void) {
+static void xol_wr_deinit() {
mkshort_del_handle(&short_h);
writer->writeEndDocument();
delete writer;
writer->writeEndElement(); // shape
}
-static void xol_write(void) {
+static void xol_write() {
double x, y;
waypt_disp_all(xol_waypt_bound_calc);
}
static void
-yahoo_read(void)
+yahoo_read()
{
xml_read();
}
static void
-yahoo_rd_deinit(void)
+yahoo_rd_deinit()
{
xml_deinit();
}
projects / gpsbabel.git / commitdiff